home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Internet Info 1994 March
/
Internet Info CD-ROM (Walnut Creek) (March 1994).iso
/
answers
/
comp
/
object-faq
/
part5
< prev
next >
Wrap
Text File
|
1993-12-15
|
60KB
|
1,432 lines
Newsgroups: comp.object,comp.answers,news.answers
Path: senator-bedfellow.mit.edu!bloom-beacon.mit.edu!nic.hookup.net!swrinde!cs.utexas.edu!howland.reston.ans.net!vixen.cso.uiuc.edu!uchinews!news
From: Bob Hathaway <rjh@geodesic.com>
Subject: Comp.Object FAQ Version 1.0.5 (12-13) Part 5/8
Message-ID: <1993Dec14.044721.18360@midway.uchicago.edu>
Followup-To: comp.object
Summary: Frequently Asked Questions (FAQ) List and Available Systems For Object-Oriented Technology
Sender: news@uchinews.uchicago.edu (News System)
Organization: Geodesic Systems
Date: Tue, 14 Dec 1993 04:47:21 GMT
Approved: news-answers-request@MIT.Edu
Lines: 1417
Xref: senator-bedfellow.mit.edu comp.object:13852 comp.answers:2993 news.answers:15751
Archive-name: object-faq/part5
Last-Modified: 12/13/93
Version: 1.0.5
Workgroup through enterprise-wide and cross-enterprise computing is supported
via a distributed client/server architecture that provides a single logical
view over multiple databases on heterogeneous machines. The user sees a
logical view of objects connected to objects and need not worry that one object
is in a database on a Sun workstation, while another may be in a database under
Windows or VMS. All operations work transparently across this environment,
including atomic transactions with two-phase commit, propagating methods, and
versioning. Objects may be moved between databases and platforms without
affecting working applications or requiring changes to the applications.
Multiple schemas may be created, without affecting other users or databases,
and may be used simultaneously with shared schemas, allowing local groups to
define their own models but still connect to other groups. Databases may be
detached from this shared environment (federated database) and used on portable
devices, reconnected or moved to different (compatible) environment, or
distributed as parts or image libraries. Gateways to RDBMSs are provided via
third-party integration with Persistence Software, and more generally to any
foreign data store, as long as the user installs the appropriate access
methods, extending the single-logical-view to include read/write access to
arbitrary foreign data stores. Together, these allow delegation of
responsibilities to the appropriate users, integration with existing systems,
and gradual migration toward full enterprise-wide sharing.
The on-demand object manager directly and automatically manages object access
and buffering, rather than relying on system facilities such as virtual memory
or user manual get/put calls. Mechanisms used include multiple buffer pools
locally and remotely, b-trees, hashing, scoped names, keys, and iterators, with
distributed catalogues for schemas and databases. A direct connection is
established between the user and the objects used, so that users do not
conflict unless and until they are competing for the same objects, thus
avoiding the traditional central-server bottleneck. Short transactions are
based on traditional (transient) locks, owned by the process, and group
together an arbitrary set of operations. Long transactions are based on
persistent locks, owned by the user, and provide the same arbitrary grouping.
Default concurrency is two-phase locking and serialization, but extensions
available include MROW, or multiple-readers concurrent with one-writer, and
allow users to lock with or without wait or with timed waits, to implement more
sophisticated mechanisms.
Objects may be modeled using C++ structures augmented by classes provided such
as strings, dictionaries, and relationship management, as well as some
particular domain libraries. A simple object is a C++ class (or C structure)
with associated access methods. A complex object may include multiple varrays,
each being a dynamically varying sized array of arbitrary structure. A
composite object is any network of related objects that acts as a single
object, both structurally and behaviorally, via propagation of behaviors to
component objects. Any number of composite objects may be contained in
composite objects, and a single object may participate in any number of
composites. The relationship mechanism supports uni- and bi-directional
relationships, one-to-one, one-to-many, and many-to-many. Versioning is
supported at object granularity, may be turned on or off at any time for each
object, may be restricted to linear or allow branching with multiple writers.
References to versioned objects may be to a specific version or to the default
version, which may be separately specified by a method and may allow multiple
defaults. Schema and object evolution are supported via versioning of the
type-defining objects. Each time a type definition is changed, its defining
object is versioned, allowing arbitrary changes. Objects may then be instances
of the old or new type version. Object evolution or upgrading to the new type
version is supported by the user writing conversion methods which are
installed and invoked by the system.
ANSI SQL query is supported in the SQL++ product. Predicate syntax may be
either C++ or SQL. The ODBC and SQL Access Group (SAG) protocols are
supported. Queries may be invoked programatically or interactively, with ad
hoc support. Access to object features is available via methods and traversal
of relationships.
Over forty administrative and developer tools are provided, each with both an
interactive and programmatic interface. These include GUI object and type
browsers, query browsers, report generator, tools to examine and force short
and long locks, to move objects and databases, etc. On-line incremental backup
provides a consistent network-wide snapshot, including referential integrity
across all databases, and runs incremental and full database backups with no
need to acquiesce the databases and no interference with active applications.
All tools are built around a messaging backplane, which supports four levels of
integration with user and third-party tools. Integrated products include HP
SoftBench (full operational level), CenterLine's ObjectCenter (tool level),
Persistence RDBMS gateway, PTech and ProtoSoft Design and Analysis (language
level), and XVT and UIM/X (compatibility level).
Objectivity/DB is resold by Digital Equipment Corporation as DEC Object/DB,
providing a multi-billion-dollar second source vendor. Over 50,000 end users
are licensed in production use, with applications including real-time
telecommunications, aerospace, defense, case, CAD/CAM, CIM, manufacturing, oil
& gas, process control, transportation, multi-media, case, document management,
financial analysis, and corporate information management. Platform support
includes all Sun, all DEC (including VMS, alpha, OSF-1), HP/9000 series (both
68xxx and PA-RISC), IBM RS/6000, NCR 3300, SGI, Windows 3.1, and Windows NT.
On Schema Evolution (from original survey):
In the just-released Version 2.0 (shipping Oct 92), schema evolution
is supported via dynamic versioning of type-defining objects [ie.
class versions -- SMC], and via a step-by-step approach that allows
conversion of instance data via user-provided conversion methods.
Also, a full dynamic type manager interface is available for doing
fancier things.
Contact:
Drew Wade
Objectivity, Inc.
800 El Camino Real
Menlo Park, CA 94025 USA
drew@objy.com
1(415)688-8000 voice
1(415)325-0939 fax
admin ass't: Vickie Clements (vickie@objy.com)
information: info@objy.com
> ObjectStore (Object Design)
Entry on Schema Evolution only:
ObjectStore does not provide schema evolution as yet but it has
promised to provide schema evolution in the next release.
[h.subramanian@trl.OZ.AU]
ObjectStore is an ODBMS produced by Object Design, Inc. Release 2,
which is in beta test now, supports schema evolution. The kinds of
evolution supported include change of a data member's type, addition
and removal of data members, and change in inheritance structure.
There are default transformations built in, (e.g. from int to float),
and user-defined transformations may be run also.
Approximately $5-8K
[Ian Schmidt, Object Design, Inc. <schmidt@odi.com>]
> Ontos [formerly VBase] (Ontologic)
Entry on schema evolution only:
*Ontos provides schema evolution. It allows any class to be modified.
*The major drawback is that data does not migrate ie., instances are
*not modified to adopt to the new class definition. So schema changes
*can be done only on classes that do not contain instances and do not
*have sub classes that contain instances.
*[h.subramanian@trl.OZ.AU]
*As a system for experiments, we are currently using ONTOS from
*Ontologic Inc. Unfortunately, there is no transparent concept of
*schema evolution for populated database. Thus, we still investigate
*how it works.
ONTOS has a version of ONTOS for OS/2. Approximately $11K. Others I don't know
> OpenODB (Hewlett-Packard)
OpenODB is an advanced object-oriented database management system
(ODBMS) from Hewlett-Packard for your complex commercial application
needs. With OpenODB, you can take advantage of new object-oriented
features combined with a robust database management system. This
combination of capabilities is unique in the industry.
OpenODB's object-oriented features will help to reduce your development
and maintenance costs by more intuitively representing your business
problems. Also, OpenODB stores code as well as data. This means that
your application will be simpler and code as well as data can be shared
between multiple users and applications.
OpenODB's database management features ensure the integrity, security
and availability of your stored code and data. At the same time,
OpenODB protects your existing data, applications and training
investment by allowing you to access existing data and applications
using the object-oriented structured query language (OSQL).
Hewlett-Packard's OpenODB product uses a client/server architecture,
enabling you to efficiently utilize your available computing power.
OpenODB's clients use the programmatic interface to access information on
the server.
OpenODB is composed of the following client and server components:
OpenODB Clients
o Interactive Object-Oriented SQL (IOSQL)
This interface allows you to interactively enter all object-
oriented SQL (OSQL) statements, facilitating rapid prototyping
and testing. IOSQL provides basic query, administration and
editing capabilities.
o Graphical Browser
The Graphical Browser is a tool that allows you to graphically
explore your database schema and contents. This tool is
designed to increase the speed of application development by
making it easier for you to find reusable code stored in
OpenODB.
o Programmatic Interface
You can write OpenODB applications using any programming
language that can be linked with C (C++, COBOL, FORTRAN,
Pascal). The programmatic interface uses OSQL statements
passed as parameters and does not require preprocessors.
o User Applications and Tools
These are the OpenODB clients you will develop using IOSQL,
the Graphical Browser and the Programmatic Interface.
OpenODB Server Components
o Object Manager
The Object Manager executes OSQL calls made by the OpenODB
clients. The Object Manager processes requests and accesses
data and code from the internal data storage manager
(Relational Storage Manager) or passes the request to a
subsystem outside of OpenODB (External Functions).
o Relational Storage Manager
OpenODB uses a relational database as its storage manager for
internally stored data and code. The relational database
performs the physical file management and database functions
such as multiuser concurrency, transaction management, and
recovery. Relational database tools are available to help you
perform online backup and recovery, manage physical
distribution of files, maximize availability and change
database parameters.
o External Functions
External functions allow you to access data and code stored
outside of OpenODB, regardless of data format or location.
They are implemented by you as subroutines written in general-
purpose programming languages and compiled outside of OpenODB.
With external functions, you can encapsulate existing
applications. External functions can be called by any OSQL
statement, allowing you to use this remote data and
application code like any other object.
OpenODB Object Model
In OpenODB, the object-oriented model is based upon three components:
objects, types and functions. These terms are defined as follows in
OpenODB:
Objects are a combination of data and stored code that operate on
the data.
Types allow you to classify similar objects.
Functions operate on data in the database and also define the
behavior of that data in the database. OpenODB supports the
following three types of user-defined functions:
* Stored functions define attributes and relationships that are
stored in the database.
* OSQL-based functions define attributes and relationships that
are retrieved or calculated with OSQL statements.
* External functions are a reference to code or data stored
outside of OpenODB.
OpenODB Language
You create and manipulate objects, types and functions using OpenODB's
object-oriented structured query language (OSQL). OSQL is a functional
language that is a semantic superset of SQL, the structured query
language used for relational databases. OSQL is a complete language
with statements that allow you to define and manipulate your OpenODB
database, specify authorization by individuals or groups, define
transactions, embed program logic within functions, and administer your
database.
Using OSQL, you can create the following schema:
+---------------+
Type | Employee | Name, Salary, Picture,
+---------------+ SalaryDeduction, WorksFor,
+----------------|----------------+ DisplayPicture
+----------------+ +-----------------+
Subtype | Manager | Manages | Programmer | Languages
+----------------+ +-----------------+
OpenODB Schema Diagram
Creating Types and Functions
The first step is to create basic types and functions using the CREATE
TYPE statement, and to create additional functions using the CREATE
FUNCTION statement. Next, using the simple OSQL statements shown in
Table 2, you can create specific objects.
Create a user-defined type called Employee with three stored
functions:
CREATE TYPE Employee
FUNCTIONS (Name CHAR,
Salary FLOAT,
Picture BINARY);
Create type Programmer, a subtype of Employee. Also define the
stored function Languages on Programmer:
CREATE TYPE Programmer SUBTYPE OF Employee
FUNCTIONS (Languages SETTYPE(CHAR));
Create type Manager, a subtype of Employee. Also define the stored
function Manages on Manager:
CREATE TYPE Manager SUBTYPE OF Employee
FUNCTIONS (Manages SETTYPE(Employee));
Create an OSQL-based function SalaryDeduction on Employee:
CREATE FUNCTION SalaryDeduction (Employee e) -> FLOAT AS OSQL
SELECT (0.3 * Salary (e));
Create an OSQL-based function WorksFor on Employee to define the
relationship with Manager:
CREATE FUNCTION WorksFor (Employee e) -> Manager AS OSQL
SELECT mgr
FOR EACH Manager mgr
WHERE e IN Manages(mgr);
Create an external function on Employee to display the employee's
picture:
CREATE FUNCTION DisplayPicture (CHAR Name) -> CHAR AS EXTERNAL
SIMPLEEXTFUN('DisplayPicture $Name');
Creating Objects
Put data into three stored functions defined on the Programmer type:
CREATE OBJECT AS Programmer
FUNCTIONS (Name, Salary, Languages)
:bob ('Bob Cox', 55000, SET('PL/1', 'C')),
:sue ('Sue Smith', 65000, SET('COBOL'));
Put data into three stored functions defined on the Manager type:
CREATE OBJECT AS Manager
FUNCTIONS (Name, Salary, Manages)
:al ('Al Ott', 70000, SET(:bob,:sue)),
:jim ('Jim Hill', 100000, SET());
Put data into three stored functions using a reference to another
object:
CREATE OBJECT AS Manager
FUNCTIONS (Name, Salary, Manages)
:chris ('Chris Jones', 80000, SET(:al,:jim));
SQL-like Queries
Select Bob's salary:
SELECT Salary (:bob);
Result: 55000
Select the names of the employees that Al manages:
SELECT Name(Manages(:al));
Results: 'Bob Cox'
'Sue Smith'
Select the names of all managers:
SELECT Name (m)
FOR EACH Manager m;
Results: 'Al Ott'
'Jim Hill'
'Chris Jones'
NOTE: The ":" denotes a temporary variable (e.g. :bob) defined in your
application to store a reference to your OpenODB object.
Development of New Applications Faster Using OpenODB, you can directly
model your business information in an intuitive way. You can also
reuse code stored in OpenODB to reduce your application backlog and
improve your productivity. To help you develop new applications
faster, OpenODB provides the following features:
Object Identity Each object stored in OpenODB has a system-provided,
unique handle called an object identifier (OID). OIDs reduce
duplication of information and relieve you from creating unique keys to
identify stored information in the database.
Complex Objects With OpenODB you can construct complex objects from
simpler objects. Complex objects relieve your application code from
managing the relationships between simple objects.
Referential Integrity Since OpenODB has knowledge of the relationships
between objects, it can manage referential integrity on your behalf.
That is, if objects referenced by other objects are deleted, the system
removes all dependencies. You can specify whether or not to "cascade"
changes or to just delete the immediate dependency. For instance, if
you delete the Employee 'Bob Cox', the function call
(Name(Manages(:al))) will return just 'Sue Smith'. The result is a
simplified database schema and simplified application code that can be
developed more quickly since you do not need to manage referential
integrity explicitly.
User-defined Data Types In addition to the primitive data types you can
construct user-defined data types in OpenODB rather than in your
application code. User-defined types give you more flexibility and
lead to more manageable, clearer code.
Type Hierarchy Types can be organized in a hierarchy. This hierarchy
of types and related functions allows you to minimize the translation
from your business model to your OpenODB schema. The hierarchy also
enables a type to inherit functions defined on "parents", eliminating
duplication of functions. You will be able to more quickly move from
application design to implementation.
Multiple Inheritance Functions defined on a type can be inherited by
one or more subtypes. By inheriting rather than redefining functions,
you can easily extend the functionality of your application.
Overloaded Functions Multiple functions can have the same name with
different implementations. In your application, all you need to do is
call a function (e.g. Salary). OpenODB will determine which code
(Salary for Employee or Salary for Manager) to execute based upon the
parameter passed at run-time. As a result, your application code is
simplified since the logic for determining which function to execute is
now in OpenODB.
Late Binding OpenODB supports functions that are resolved at run-time.
Late binding allows you more flexibility in application development and
gives you the full power of overloaded functions as described above.
Late binding also shields your applications from changes to functions
since these changes can be made online and the new function definition
resolved at run-time.
Reduced Maintenance Costs OpenODB allows you to add new functionality
and make schema changes to your OpenODB database at run-time, often
without changing your application code or even stopping the database
system. The following OpenODB features will help reduce your
maintenance costs:
Dynamic Schema Modification You can create new functions and types in
OpenODB at runtime. You can also change the implementation of
functions without having to recompile your applications.
Dynamic Typing You can dynamically change the type of an object without
having to destroy and recreate the object. This is possible because an
object can belong to more that one type.
Encapsulation OpenODB supports the combination of data and user-defined
functions. Since OpenODB only allows access to your data through these
functions, your application is protected from changes to the function
implementation and you have control over how users access information
in OpenODB. Encapsulation allows you to modify the function body
without changing your application code.
Procedural Language OSQL includes programming flow statements,
including IF/THEN/ELSE, FOR and WHILE. The procedural language allows
OpenODB functions to be quite complex, simplifying your application
code. By moving application code into the database, you can now share
the code and get all of the benefits of sharing data, such as
consistency, security and integrity.
For example...
Create a Procedure
Convert all managers to programmers that have less than a specified
number of employees:
CREATE FUNCTION MgrToEng (INTEGER minemps) -> BOOLEAN
AS OSQL
BEGIN
FOR m IN Manager DO
IF (COUNT(Manager (m)) < minemps)
THEN
BEGIN
ADD TYPE Programmer TO m;
REMOVE TYPE Manager FROM m;
END
ENDIF;
END;
Executing a Procedure
Applications are simplified since the implementation of functions can
now be stored in OpenODB. Simply call a function, passing a parameter:
CALL MgrToEng(3);
Protection of Existing Investments OpenODB coexists with your current
data and applications, allowing you to build upon existing
functionality. Also, OpenODB's object-oriented SQL (OSQL) is easy to
learn if you already know Structured Query Language (SQL).
External Functions Using external functions, you can access distributed
data and code stored outside of OpenODB, regardless of data format or
location. This simplified view of your enterprise allows you to more
easily develop complex applications that integrate your existing data
and applications. For instance, you can develop an OpenODB application
that accesses data stored in other databases (e.g. ALLBASE/SQL,
TurboImage or DB2) as well as in flat files. OpenODB acts as an
integrator so that your application just needs to know OSQL. OSQL
statements may actually call functions that access data and encapsulate
code stored outside of OpenODB.
OSQL If you already know SQL, you can quickly be productive using
OpenODB's OSQL. OSQL uses syntax that is similar to SQL, the semantics
are a superset of SQL, and both query languages are set-based, that is
they retrieve sets of information based upon queries, as shown in
earlier examples.
Optimize Performance and Availability OpenODB, with the help of the
underlying relational storage manager, gives you flexibility in
managing the performance of your system and maximizing the availability
of information for your users.
High Availability
OpenODB maximizes the availability of your information by providing:
* dual logging, to ensure the integrity of your log file
* switch log, to automatically switch to a second log file if the
original log file is damaged or becomes full
* dynamic file expansion, to automatically expand the size of your
system file if it becomes full
* online backup of the database, to backup the database while it is
being accessed OpenODB will also take advantage of available system
features such as disc mirroring.
Multiuser Concurrency Control OpenODB is designed to support hundreds
of users accessing the same information while guaranteeing the
integrity of that information.
Compiled Functions To improve runtime performance, functions are
compiled and can be cached.
Access Methods on Stored Data Indexes are automatically defined on
object identifiers (OIDs) for you when you create types and functions.
These indexes help provide quick access to information stored in your
OpenODB ODBMS. You can also define your own indexes.
Clustering Related functions can be stored close to each other in order
to improve performance.
Additional Features
Authorization You can control access to OpenODB at the database and
function levels based on individuals or a group of users. Authorization
statements provide you a flexible way to control access to types and
functions in OpenODB.
Client/Server Architecture Clients communicate with the OpenODB server
over a network. The interface between the clients and the server is
transparent to you as a user. The clients and server can also reside
on the same machine.
Multimedia OpenODB allows you to store large, unformatted data in
binary format. Some examples include graphics, images or voice. You
can also define functions in OpenODB to manipulate this multimedia
information. For example, you can store a picture as well as the
function to display the picture.
Native Language Support You can store 8-bit and 16-bit character data
in OpenODB.
Persistent Data and Code OpenODB allows you to save data as well as
code between application sessions.
Primitive Data Types OpenODB supports a number of primitive data types,
shown in the OpenODB Feature Summary below. You can also create your
own user-defined data types.
Recovery OpenODB has a robust logging and recovery facility. In case
of a failure, OpenODB can handle rollback or rollforward recovery to a
particular time, using your log file to recreate saved work.
Transaction Management OpenODB ensures the logical and physical
integrity of your database by giving you complete control over the unit
of work to be performed within a single transaction. With this
control, you can save or rollback a transaction (throw away temporary
work) at your discretion. Savepoints are supported so that you can
rollback parts of a transaction.
System Environment The OpenODB server and all clients are available on
HP-UX 8.0 or later versions for the HP9000 Series 300/400/700/800
systems and for MPE XL 4.0 or later versions for the HP3000 Series 900
systems. Client software will also be supported using X terminals.
You will need 16 Mbytes of main memory (32 Mbytes recommended), at
least 15 Mbytes disc space for installation and approximately 10 Mbytes
DISC space for each new OpenODB database.
Software Requirements To use OpenODB, you need to have a TCP/IP
transport and ARPA Berkeley Services. To use the OpenODB Graphical
Browser, you need to have X-Window X11.
Ordering Information The software includes: OpenODB clients (IOSQL,
Graphical Browser, Programmatic Interface) and the 1-8 user license for
the OpenODB server (Object Manager, Runtime ALLBASE/SQL and External
Functions). You must specify a media option for the HP9000 systems.
Product Number Product Description
B2466A OpenODB Developer Release for HP9000 S300/S400
B2468A OpenODB Developer Release for HP9000 S700
B2470A OpenODB Developer Release for HP9000 S800
B2472A OpenODB Developer Release for HP3000 S900
Documentation, Online Support, Training and Consulting The OpenODB
Developer Release includes documentation for all systems. The OpenODB
Developer Release also includes online support, training and
consulting. These services will be arranged when you place an order
for the product.
OBJECT-ORIENTED FEATURES CLIENT INTERFACES
Complex Objects Interactive OSQL
Dynamic Schema Modification Graphical Browser
Dynamic Typing Programmatic Interfaces: C
Encapsulation linkable languages (C++,
External Functions COBOL, FORTRAN, Pascal)
Functions (Stored Code or Methods)
Late Binding OSQL STATEMENTS
Multiple Inheritance Add/Remove Type To/From Object
Object Identity (OID) Add/Remove User
Overloaded Functions Call Function
Type (Class) Hierarchy Change Password
User-defined Data Types Create/Delete Function
Create/Delete Object
DBMS FEATURES Create/Delete Type
Access Methods on Stored Data Create/Delete User/Group
Authorization (Security) Grant/Revoke
Client/Server If/Then/Else, While, For
Clustering Implement Function
Compiled Function Open/Fetch/Close Cursor
Declarative Query Language (OSQL) Select
High Availability Update
Multimedia
Multiuser Concurrency Control PRIMITIVE DATA TYPES
Native Language Support Binary
Persistence Boolean
Primitive Data Types Character
Procedural Language Date
Recovery Datetime
Referential Integrity Decimal
Transaction Management Floating Point
Integer
Interval
Long Binary (Large)
Small Integer
Time
OpenODB Feature Summary
HP OpenODB Price Guide
SUMMARY:
Description U.S. List Price
1. Developer's Bundle $105,000
2. Evaluator's Bundle $5,000
3. Learning Version $10,000
4. Training Course $2,500/person
5. Consulting $3,500/day or Quote
6. Reference Manual $250
DETAILED DESCRIPTION:
1. Developer's Bundle
Contents:
A) OpenODB software (1-64 User License for 1 Server Platform)
B) OpenODB documentation
C) 5 passes to the OpenODB Training Course
D) 5 days of on-site consulting
E) Phone and software update support for 6 months
U.S. List Price: $105,000/bundle
Product Numbers:
B2472A (for HP 3000 Series 900 with MPE/iX)
B2468A (for HP 9000 Series 700 with HP-UX)
B2470A (for HP 9000 Series 800 with HP-UX)
Notes:
A) OpenODB documentation includes the OpenODB Reference Manual, ALLBASE/SQL
Handbook of DBA Tasks, and Up and Running with ALLBASE/SQL.
B) The OpenODB Training Course is delivered in Cupertino, California and takes
4 days.
C) Consulting is provided at the customer's site with a maximum of two trips.
D) Phone support is provided directly from the HP OpenODB factory consulting
team in Cupertino, California. Phone and software update support can be
purchased at the end of the first 6 months at the rate of $6,900 per year.
E) Volume End User (VEU) and Educational discounts apply to the entire list
price.
F) The Developer's Bundle is available on HP 3000 Series 900 or HP 9000 Series
700 and 800 computers.
2. Evaluator's Bundle
Contents:
A) 3 months use of OpenODB software (1-64 User License for 1 Server Platform)
B) OpenODB documentation
C) 1 pass to the OpenODB Training Course
D) Phone support for 3 months
U.S. List Price: $5,000/bundle
Product Numbers:
B3178A (for HP 9000 Series 700 with HP-UX)
B3179A (for HP 9000 Series 800 with HP-UX)
Notes:
A) The OpenODB software is shipped when the product is ordered. The OpenODB
software will stop running 3 months after it is installed.
B) OpenODB documentation includes the OpenODB Reference Manual, ALLBASE/SQL
Handbook of DBA Tasks, and Up and Running with ALLBASE/SQL.
C) The OpenODB Training Course is delivered in Cupertino, California and takes
4 days.
D) Phone support is provided directly from the HP OpenODB factory consulting
team in Cupertino, California.
E) Volume End User and Educational discounts apply to the entire list price.
F) The Evaluator's Bundle is only available on HP 9000 Series 700 or 800
computers.
3. Learning Version
Contents:
A) OpenODB learning version software (Single User License for 1 Platform)
B) OpenODB documentation
U.S. List Price: $10,000/license
Product Numbers:
B3181A (for HP 9000 Series 700 with HP-UX)
B3182A (for HP 9000 Series 800 with HP-UX)
Notes:
A) This special single user version is intended for students, researchers, and
technical evaluators who wish to learn about the Object-oriented SQL (OSQL)
interface language and OpenODB product. The learning version software runs
on one computer for one user application (i.e. no client/server mode).
B) OpenODB documentation includes the OpenODB Reference Manual, ALLBASE/SQL
Handbook of DBA Tasks, and Up and Running with ALLBASE/SQL.
C) Volume End User and Educational discounts apply to the list price.
D) The Learning Version is available on HP 9000 Series 700 and 800 computers.
E) Phone and software update support for the Learning Version can be
purchased at the rate of $1,500 per year.
4. OpenODB Training Course
Contents:
A) 1 pass to the OpenODB Training Course
B) OpenODB documentation
C) Class notes and OSQL case study examples
U.S. List Price: $2,500/person
Product Number:
B3184A
Notes:
A) The OpenODB Training Course is delivered in Cupertino, California and takes
4 days.
B) OpenODB documentation includes the OpenODB Reference Manual, ALLBASE/SQL
Handbook of DBA Tasks, and Up and Running with ALLBASE/SQL.
C) The OpenODB Training Course includes hands on experience with the OpenODB
software through a case study approach.
D) No standard discounts apply.
5. OpenODB Consulting
Contents:
A) 1 person on the customer's site for technical consulting
U.S. List Price: $3,500/day + zone charge/trip
Product Number:
B3186A
Notes:
A) For details about this consulting, see the OpenODB Consulting Fact Sheet.
B) The zone charges per trip are: $1000 in North America, $2000 in Europe,
and $3000 in the Far East and South America.
Consulting that does not require travel will not have a zone charge.
C) Special quotes are available for projects longer than one week.
D) No standard discounts apply.
6. OpenODB Reference Manual
Contents:
A) OpenODB Reference Manual
B) The right to make up to 5 additional copies of the OpenODB Reference Manual
for internal use only.
U.S. List Price: $250/manual & right to copy
Product Number: B3185A
Notes:
A) No standard discounts apply
Mark Boronkay
OpenODB Consultant
boronkay@cup.hp.com
> POET <Persistent Objects and Extended Database Technology> (BKS Software)
C++ Language Support
o tight semantic integration with C++
o any C++ object or structure can be made persistent by adding the
persistent keyword
o storing and reading a C++ object does not change its state or behavior
o full support for C++ encapsulation, object identity, inheritance, and
polymorphy
o C++ pointers and references are automatically converted to database
references when storing objects
o database references are automatically converted to C++ pointers and
references when reading objects
o all database definition is done through a small extension to C++
declaration syntax
Database Functionality
navigation, queries, sorting, indexes, single-user operation, multi-user
operation using client/server architecture, flexible locking for objects
and sets, nested transactions, watch & notify for objects and sets,
event handling, database size limited only by hard disk size
C++ Language Extensions
persistence, indexes, transient data elements in persistent classes, sets,
dependent objects
PTXX-Precompiler
automatically converts extended C++ class declarations into ANSI 2.0 code,
registers classes in the class dictionary, provides class versioning
Predefined C++ Classes
date, time, strings, and BLOBS (binary large objects)
Portability
all platforms are source-code compatible, any POET database may be read by
any computer full support for heterogeneous networks
Platforms
Available for MS-DOS / MS-Windows (Borland C++, Microsoft),
OS/2 (Borland C++), Novell, Macintosh MPW, and various Unix
systems, including NeXT (NeXTStep) and Sun OS (Sun C++).
How to Contact Us:
BKS has offices in Santa Clara, Hamburg, and Berlin. Silicon
River, Limited, is responsible for POET in the United Kingdom.
Santa Clara: (North America, Australia, Asia)
BKS Software
4633 Old Ironsides Drive Suite 110
Santa Clara, CA 95054
Phone: 408 / 748 - 3403
Fax: 408 / 748 - 9060
Contact Person: jrobie@netmbx.netmbx.de (Jonathan Robie)
> Statice (Symbolics)
From: fischerm@darmstadt.gmd.de (Markus Fischer)
Newsgroups: comp.databases.object,comp.lang.lisp
Subject: Statice now runs on Unix
Date: 15 Jun 93 14:55:48 GMT
Hi there,
since I've never seen 'Symbolics' or 'Statice' in
comp.database.object, this might be interesting:
A few days ago, Symbolics announced the availability of a beta-
release of their ODBMS 'Statice' on Unix platforms. It is quite
powerful and tightly integrated within Common Lisp.
Currently, Symbolics and LUCID are supported.
People (like me) used to Symbolics' Genera development environment
can continue to use Statice there (where it has been already
successfully employed in 'real world' applications)
and now also use it on Unix Workstations. (Those are the cheaper
boxes, I guess). Both kinds of platforms can be freely intermixed
in a network.
Statice is based on standards of Lisp: CLOS and CLIM
(Common Lisp Object System, resp. Common Lisp Interface Manager)
Here's the address of Symbolics in Germany; they're mostly
responsible for Statice on Unix:
Symbolics Systemhaus GmbH
Mergenthalerallee 77
6236 Eschborn (til June 31)
65760 Eschborn (from July 1)
Tel. (49) 6196-47220, Fax (49) 6196-481116
Contact person is Dr. Thomas Neumann (TN@symbolics.de).
Also:
"Update Database Schema" brings an existing database into conformance
with a modified schema. Changes are classified as either compatible
(lossless, i.e., completely information-preserving) or incompatible
(i.e., potentially information-losing in the current implementation).
Basically, any change is compatible except for the following:
-- If an attribute's type changes, all such attributes extant
are re-initialized (nulled out). Note that Statice permits
an attribute to be of type T, the universal type. Such an
attribute can then take on any value without schema
modification or information loss.
-- If a type's inheritance (list of parents) changes, the
type must be deleted and re-created, losing all extant
instances of that type. This is Statice's most serious
current limitation. The simplest workaround is to employ a
database dumper/loader (either the one supplied by Symbolics
or a customized one) to save the information elements and
then reload them into the modified schema.
[Lawrence G Mayka <lgm@IExist.ATT.COM>]
> UniSQL
UniSQL offers a state-of-the-art suite of integrated object-oriented database
systems and application development products which can be used separately or
together to support complex development projects which use object-oriented
development techniques, integrate sophisticated multimedia data, and require
true multidatabase access to relational and object-oriented databases. The
UniSQL product suite includes:
UniSQL/X Database Management System;
UniSQL/M Multidatabase System; and
UniSQL/4GE Application Development Environment
User interfaces include: C++, C, Object SQL, SmallTalk, and ODBC
Database interfaces include: Ingres, Oracle, Sybase, UniSQL/X, and EDA/SQL
UniSQL offers:
- A wide selection of user interfaces including C++, SmallTalk, C, Microsoft's
ODBC, both embedded (static and dynamic) and interactive Object SQL, and UniSQL
and 3rd-party development tools.
- Mission-critical database features such as a high-level query language
(SQL/X), cost-based query optimization, automatic transaction management,
automatic concurrency control, dynamic schema evolution, dynamic authorization,
physical disk structuring options, and installation tuning parameters.
- The UniSQL Multimedia Framework which provides natural and uniform database
system support for all types of large unstructured data objects. The Multimedia
Framework also provides for seamless integration of multimedia devices such as
fax machines, CD jukeboxes, satellite feeds, image compression boards, etc.
- The UniSQL/M Multidatabase System enables developers to manage a collection
of multi-vendor databases -- Ingres, Oracle, Sybase, DB2, UniSQL/X, and others
-- as a single federated database system with full object-oriented
capabilities.
UniSQL has well over 150 customers around the world, the majority of which are
using UniSQL database products for mission-critical applications which require
object-oriented, multimedia, post-relational, and heterogeneous database
capabilities.
A typical UniSQL customer is a Fortune 500 company, a commercial software
developer, or government organization that is using UniSQL database products
to:
- support mission-critical application development projects which are being
developed using object-oriented programming languages and development
techniques,
- support applications which must integrate many different types of corporate
data -- text and documents, tabular data, images and audio, engineering
drawings, GIS data, procedural data (programs), etc. -- into a single
application context.
- support the full object-oriented development paradigm using existing
relational database systems such as Ingres, Oracle, Sybase, and DB2.
- logically integrate one or more relational and object-oriented databases to
form a single, homogenized database server which supports both relational and
object-oriented facilities.
In September 1992, UniSQL was selected by the Petrotechnical Open Software
Corporation (POSC) -- over more than 25 other industry vendors -- to provide
database technology which is being used by POSC in their development of a new
data management specification for the oil & gas industry. Also during 1992,
because of its powerful multimedia capabilities, UniSQL was selected by the MIT
AthenaMuse Consortium on multimedia as the consortium's multimedia database
system.
During the DB/EXPO '93 Conference and Exhibition, UniSQL was chosen in
competition with major industry database vendors as a finalist in the
``RealWare Awards''. The ``RealWare Awards'' honor companies that have
had a major impact in the user community.
UniSQL was founded in May 1990 by Dr. Won Kim, President and CEO, delivering
the UniSQL/X DBMS in March of 1992. With its world-class database research and
architectural team, UniSQL has perfected what the database industry has sought
since the mid-1980s: a fully object-oriented data model that is a natural
conceptual outgrowth of the popular relational model. Both the UniSQL/X DBMS
and the UniSQL/M Multidatabase System represent the first of a powerful new
generation of client-server database systems that support the full
object-oriented paradigm yet retain all of the strengths and capabilities of
relational database systems including support for ANSI-standard SQL.
UniSQL currently has 45 employees and is privately owned and managed by Dr.
Kim. The company has secured long-term funding from NTT Data Communications
Systems Corp. (NTT Data), a $2 billion company, which is Japan's foremost
systems integrator and UniSQL's exclusive distributor in Japan.
For more information, contact:
UniSQL, Inc.
9390 Research Blvd., II-200
Austin, Texas 78759-6544
Tel.: 512/343-7297
Tollfree: 800/451-DBMS
Fax.: 512/343-7383
And:
From: jonh@unisql.UUCP (Jon Higby)
Newsgroups: comp.databases,comp.databases.theory,comp.databases.object,comp.object
Subject: Re: SQL3, Itasca, & UniSQL/X
Message-ID: <6143@unisql.UUCP>
Date: 10 Sep 93 14:26:04 GMT
References: <CD1Ln5.9G3@dcs.glasgow.ac.uk>
Organization: UniSQL, Inc., Austin, Texas, USA
>>...
For UniSQL/X, feel free to contact me (email, snail-mail or phone).
UniSQL/X is a SQL compliant database with Object Oriented extensions
(classes, inheritance, methods, etc). We have an information packet
available which includes a white-paper on our OORDMS approach.
Jon Higby
Technical Services Consultant
UniSQL, Inc.
9390 Research II, Suite 200
Austin, Texas 78759-6544
(512) 343-7297
*****************************************************************************
Standard disclaimer ... All opinions expressed are my own and not of my
employer.......................................
*****************************************************************************
> Versant (Versant Object Technology)
Versant is a client/server object database management system (ODBMS) targeted at
distributed, multi-user applications. Versant runs on UNIX and PC platforms,
including Sun, IBM, HP, DEC, SGI, Sequent, OS/2, with support for Windows NT is
planned during 1993.
Versant provides transparent language interfaces from object-oriented
programming languages such as C++ and Smalltalk. Versant also supports a C API.
Versant is built with an object-level architecture, which means that operations
are generally performed on the object (or group thereof) level. Key Versant
features include:
Performance
-----------
* Object-level locking for fine granularity concurrency control
* Server-based query processing to reduce network I/O
* Dual caching to speed warm traversals
* Dynamic space reclamation and reuse
Distribution
------------
* Immutable, logical object identifiers for data integrity
* Object migration (transparent relocation across nodes)
* Transparent cross-node references (distributed db)
* Automatic two-phase commit
Other
-----
* Schema evolution (online via lazy updates)
* Standard workgroup features (e.g., versioning, checkin/out)
* Detachable, personal databases
* DBA utilities
Additional information available from
info@versant.com (General information)
davek@versant.com (Dave Kellogg)
Versant Object Technology
1380 Willow Road
Menlo Park, California 94025
415-329-7500 phone.
415-325-2380 fax.
On Schema Evolution (from original survey):
We support run-time schema evolution. It uses a lazy scheme, so
schema operations are very fast. Objects on disk may have an older
`storage class' and they will be updated to the new schema when they
are used.
In older releases schema evolution was allowed only on leaf classes
(those with no subclasses). In our new release 2 (going to beta test
soon) you can do schema evolution on any class.
In the future we're working on more general view mechanisms so you can
see a subset of the attributes in memory, or some more complicated
transformation. This goes together with support for multiple
compilers and multiple languages.
[Joe Keane <osc!jgk@amd.com>]
Also: 1-800-Versant
Other Models
------------
Research Systems
________________
> GRAS
--------------------------------------------------------------
GRAS - A Graph-Oriented Database System for SE Applications
Copyright (C) 1987-1993 Lehrstuhl Informatik III, RWTH Aachen
--------------------------------------------------------------
See the GNU Library General Public License for copyright details.
Contact Adresses:
Dr. Andy Schuerr
Lehrstuhl fuer Informatik III,
University of Technology Aachen (RWTH Aachen),
Ahornstr. 55,
D-5100 Aachen
Email to
andy@i3.informatik.rwth-aachen.de
GRAS is a database system which has been designed according
to the requirements resulting from software engineering
applications. Software development environments are composed
of tools which operate on complex, highly structured data.
In order to model such data in a natural way, we have selected
attributed graphs as GRAS' underlying data model.
A first prototype of the GRAS (GRAph Storage) system - described
in /BL 85/ - was already realized in 1985. Since this time
gradually improving versions of the system have been used at
different sites within the software engineering projects
IPSEN /Na 90/, Rigi /MK 88/, MERLIN /DG 90/, and CADDY /EHH 89/.
Based on these experiences, almost all parts of the original
prototype have been redesigned and reimplemented.
Thus, nowadays a stable and efficiently working single-process
version of the system GRAS with interfaces for the programming
languages Modula-2 and C is available as free software for Sun
workstations (the GRAS system itself is implemented in Modula-2
and consists of many layers which might be reusable for the
implementation of other systems):
Via anonymous ftp from ftp.informatik.rwth-aachen.de
in directory /pub/unix/GRAS in file gras.<version-no>.tar.Z.
There are several files containing documentation, sources, binaries,
application examples, and libraries. All binaries are for Sun/4
machines. Sun/3 binaries are shipped only if explicitly requested.
You have to use the following sequence of operations for installing
the GRAS system at your site:
1) 'ftp ftp.informatik.rwth-aachen.de' (with login name "anonymous"
and password equal to your mail address).
2) 'cd pub/unix/GRAS' (for changing the current directory).
3) 'binary' (command for changing ftp mode).
4) 'get gras.<version-no.>' (use 'ls' for finding the currently used
GRAS version nr.).
5) 'bye' (for exiting ftp).
6) 'uncompress gras.<version-no>.tar'.
7) 'tar xvf gras.<version-no>.tar' (creates a subdirectory GRAS_2 for
the Modula-2 implementation of GRAS including its C-interface).
8) Follow the instructions in file GRAS_2/README.
The current version has programming interfaces for Modula-2 and C
and supports:
- the manipulation of persistent attributed, directed node- and
edge-labeled graphs (including the creation of very long
attributes and of attribute indexes).
- the manipulation of temporary/volatile generic sets/relations/lists,
- the coordination of graph accesses by different GRAS applications
(multiple-read/single-write access with graphs as lock units),
- error recovery based on shadow pages and forward logs,
- nested transactions and linear undo/redo of arbitrarily long
sequences of already committed graph modifying operations based
on forward and backward logs,
- event-handling (with certain kinds of graph-modifications
as events and graph-modifying transactions as event-handlers),
- primitives for version control comprising the capability
for efficiently storing graphs as forward/backward deltas to
other graphs,
- and primitives for declaring graph schemes and for incremental
evaluation of derived attributes.
Furthermore, tools for (un-)compressing graphs and a X11R5-based
graph browser are part of this release.
A multi-process version of the system GRAS supporting the inter-
action of multiple client and multiple server processes within
one local area network is nearby completion (version 6.0/0).
Thus, the GRAS system may be considered to be the core of a graph
oriented DBMS environment. The development of such an environment
based on a very high-level specifications language named PROGRES
is under way (the underlying calculus of this specifcation language
are so-called PROgrammed GRaph REwriting Systems).
This environment will comprise the following tools (a prerelease
of this environment might be made available upon request):
- a syntax-directed editor for graph schemes, graph rewrite rules,
and sequences of graph rewrite rules,
- an incrementally working consistency checker,
- an incrementally working compiler&interpreter translating
PROGRES specifications into sequences of GRAS procedure
calls (for C as well as for Modula-2),
- and an "enhanced" graph (scheme) browser.
References
----------
Refer to the following publications for further info about GRAS, PROGRES,
and related topics:
/BL85/ Brandes, Lewerentz: A Non-Standard Data Base System within
a Software Development Environment. In Proc. of the Workshop
on Software Engineering Environments for Programming-in-the-
Large, pp 113-121, Cape Cod, June 1985
/DHKPRS90/ Dewal, Hormann, Kelter, Platz, Roschewski, Schoepe: Evaluation
of Object Management Systems. Memorandum 44, University
Dortmund, March 1990
/Feye92/ Feye A.: Compilation of Path Expressions (in German), Diploma
Thesis, RWTH Aachen (1992)
/Hoefer92/ Hoefer F.: Incremental Attribute Evaluation for Graphs (in
German), Diploma Thesis, RWTH Aachen (1992)
/HPRS90/ Hormann, Platz, Roschweski, Schoepe: The Hypermodel Benchmark,
Description, Execution and Results. Memorandum 53, University
Dortmund, September 1990
/KSW92/ * Kiesel, Schuerr, Westfechtel: GRAS, A Graph-Oriented Database
System for (Software) Engineering Applications. Proc. CASE 93,
Lee, Reid, Jarzabek (eds.): Proc. CASE '93, 6th Int. Conf. on
Computer-Aided Software Engineering, IEEE Computer Society
Press (1993), pp 272-286
Also: Technical Report AIB 92-44,
/Klein92/ Klein P.: The PROGRES Graph Code Machine (in German), Diploma
Thesis, RWTH Aachen (1992)
/Kossing92/ Kossing P.: Modelling of Abstract Syntax Graphs for normalized
EBNFs (in German), Diploma Thesis, RWTH Aachen (1992)
/LS88/ Lewerentz, Schuerr: GRAS, a Management System for Graph-
Like Documents. In Proceedings of the Third International
Conference on Data and Knowledge Bases, Morgan Kaufmann
Publ. Inc. (1988), pp 19-31
/Nagl89/ Nagl (ed.): Proc. WG'89 Workshop on Graphtheoretic Concepts
in Computer Science, LNCS 411, Springer-Verlag (1989)
/NS91/ Nagl, Schuerr: A Specification Environment for Graph Grammars,
in Proc. 4th Int. Workshop on Graph-Grammars and Their
Application to Computer Science, LNCS 532, Springer-
Verlag 1991, pp 599-609
/Schuerr89/ Schuerr: Introduction to PROGRES, an Attribute Graph Grammar
Based Specification Language, in: /Nagl89/, pp 151-165
/Schuerr91a/ * Schuerr: PROGRES: A VHL-Language Based on Graph Grammars,
in Proc. 4th Int. Workshop on Graph-Grammars and Their
Application to Computer Science, LNCS 532, Springer-
Verlag 1991, pp 641-659
Also: Technical Report AIB 90-16
/Schuerr91b/ Schuerr: Operational Specifications with Programmed Graph
Rewriting Systems: Theory, Tools, and Applications,
Dissertation, Deutscher Universitaetsverlag (1991) (in German)
/SZ91/ * Schuerr, Zuendorf: Nondeterministic Control Structures for
Graph Rewriting Systems, in Proc. WG'91 Workshop in Graph-
theoretic Concepts in Computer Science, LNCS 570, Springer-
Verlag 1992, pp 48-62
Also: Technical Report AIB 91-17
/Westfe89/ Westfechtel: Extension of a Graph Storage for Software
Documents with Primitives for Undo/Redo and Revision Control.
Technical Report AIB Nr. 89-8, Aachen University of Technology,
1989
/Westfe91/ Westfechtel: Revisionskontrolle in einer integrierten Soft-
wareentwicklungsumgebung, Dissertation, RWTH Aachen, 1991
/Zuendorf89/ Zuendorf: Kontrollstrukturen fuer die Spezifikationssprache
PROGRES, Diplomarbeit, RWTH Aachen, 1989
/Zuendorf92/ * Zuendorf A.: Implementation of the Imperative/Rule Based
Language PROGRES, Technical Report AIB 92-38, RWTH Aachen,
Germany (1992)
/Zuendorf93/ * Zuendorf A.: A Heuristic Solution for the (Sub-) Graph
Isomorphism Problem in Executing PROGRES, Technical
Report AIB 93-5, RWTH Aachen, Germany (1993)
* : All reports marked with an asterisk are available via anonymous ftp from
ftp.informatik.rwth-aachen.de in directory /pub/reports/... .
See also PROGRES documentation.
[See also APPENDIX E]
> IRIS (HP Labs)
[Iris is a system out of HP Labs that began as a prototype and eventually
became a commercial product. I believe it was eventually incorporated into
the new HP product, OpenODB. - clamen]
Long and short system summaries can be found in:
[FISH89] D.H. Fishman et. al. Overview of the Iris DBMS. In Won.
Kim and Frederick H. Lochovsky, editors,
Object-Oriented Concepts, Databases and Applications,
chapter 10, pages 219--250. Addison-Wesley, Reading,
MA, 1989.
[FBC+87] D.H. Fishman, D. Beech, H.P. Cate, E.C. Chow,
T. Connors, J.W. Davis, N. Derrett, C.G. Hock, W. Kent,
P. Lyngbaek, B. Mahbod, M.A. Neimat, T.A. Tyan, and
M.C. Shan. Iris: An object-oriented database
management system. ACM Transactions on Office
Information Systems, 5(1):48--69, January 1987.
The abstract of the latter (written early in the project) follows:
The Iris database management system is a research prototype of
a next-generation database management system intended to meet
the needs of new and emerging database applications, including
office automation and knowledge-based systems, engineering
test and measurement, and hardware and software design. Iris
is exploring a rich set of new database capabilities required
by these applications, including rich data-modeling
constructs, direct database support for inference, novel and
extensible data types, for example to support graphic images,
voice, text, vectors, and matrices, support for long
transactions spanning minutes to many days, and multiple
versions of data. These capabilities are, in addition to the
usual support for permanence of data, controlled sharing,
backup and recovery.
The Iris DBMS consists of (1) a query processor that
implements the Iris object-oriented data model, (2) a
Relational Storage Subsystem (RSS) -like storage manager that
provides access paths and concurrency control, backup and
recovery, and (3) a collection of programmatic and interactive
interfaces. The data model supports high-level structural
abstractions, such as classification, generalization, and
aggregation, as well as behavioral abstractions. The
interfaces to Iris include an object-oriented extension to
SQL.
On Schema Evolution (from original survey):
Objects in the Iris system may acquire or lose types dynamically.
Thus, if an object no longer matches a changed definition, the user
can choose to remove the type from the object instead of modifying the
object to match the type. In general, Iris tends to restrict class
modifications so that object modifications are not necessary. For
example, a class cannot be removed unless it has no instances and new
supertype-subtype relationships cannot be established.